package com.example.toolproject.demo.controller;

import com.alibaba.fastjson.JSONObject;
import com.example.toolproject.demo.domain.User;
import com.example.toolproject.demo.service.UserService;
import com.example.toolproject.demo.util.ResultBean;
import com.example.toolproject.demo.util.iputil.AddressUtils;
import com.example.toolproject.demo.util.iputil.IpUtils;
import com.example.toolproject.demo.util.jwt.JwtUtil;
import com.example.toolproject.demo.util.redis.RedisUtil;
import com.example.toolproject.demo.util.sendMessage.SendMail;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.UUID;

/**
 * @ClassName LoginController
 * @Description TODO    用户登录注册找回密码操作
 * @Author lvyongwei
 * @Date 2020-06-12 9:26
 **/
@Controller
/**
 * 解决跨域
 */
@CrossOrigin
@RequestMapping("/user")
public class LoginController {

    /**
     * 邮箱工具类
     */
    /*@Autowired
    private SendMail sendMail;*/

    /**
     * redis工具类
     */
    @Autowired
    private RedisUtil redisUtil;

    @Autowired
    private UserService userService;

    private Logger logger = LoggerFactory.getLogger(LoginController.class);

    /**
     * 向用户邮箱发送验证码
     *
     * @param mail 邮箱号码
     * @return
     */
    @PostMapping("/sendMailCode")
    @ResponseBody
    public ResultBean sendMailCode(@RequestBody String mail) {
        /**
         * 解析获取邮箱验证码
         */
        JSONObject rootObject = JSONObject.parseObject(mail);
        String realAddress = rootObject.getString("mail");
        return sendMail(realAddress);
    }

    /**
     * 注册时发送邮件的方法
     *
     * @param mail
     * @return
     */
    public ResultBean sendMail(String mail) {
        if (mail == null || mail.equals("")) {
            return ResultBean.error("邮箱号码为空");
        }
        /**
         * 生成六位验证码
         *    Math.random()取值范围是[0.0,1.0)因此预防值为0.01,0.001...加上100000
         */
        int code = (int) (Math.random() * 1000000 + 100000);
        boolean flag = SendMail.sendMail(mail, "用户注册验证码-文旅融合虚拟仿真实验", "您好！<br> " +
                "欢迎使用文旅融合虚拟仿真实验教学项目，期待给您带来更大的收获<br><br>" +
                "您的验证码为:" + code + "。此验证码三分钟有效，请及时注册");
        if (flag) {
            /**
             * 发送成功后
             * 将生成的邮箱验证码存放入redis
             */
            //单位是秒
            redisUtil.set(mail, code, 180);
            return ResultBean.success("验证邮件发送成功");
        } else {
            try {
                redisUtil.del(mail);
            } catch (Exception e) {
                logger.error("验证邮件发送失败，根据邮箱删除出错");
            }
            return ResultBean.error("验证邮件发送失败");
        }
    }

    /**
     * 找回密码时发送邮件的方法
     *
     * @param mail
     * @return
     */
    public ResultBean sendMail2(String mail) {
        if (mail == null || mail.equals("")) {
            return ResultBean.error("邮箱号码为空");
        }
        /**
         * 生成六位验证码
         *    Math.random()取值范围是[0.0,1.0)因此预防值为0.01,0.001...加上100000
         */
        int code = (int) (Math.random() * 1000000 + 100000);
        boolean flag = SendMail.sendMail(mail, "用户忘记密码验证码-文旅融合虚拟仿真实验", "您好！<br> " +
                "欢迎使用文旅融合虚拟仿真实验教学项目，期待给您带来更大的收获<br><br>" +
                "您的验证码为:" + code + "。此验证码三分钟有效，请及时注册");
        if (flag) {
            /**
             * 发送成功后
             * 将生成的邮箱验证码存放入redis
             */
            //单位是秒
            redisUtil.set(mail, code, 180);
            return ResultBean.success("验证邮件发送成功");
        } else {
            try {
                redisUtil.del(mail);
            } catch (Exception e) {
                logger.error("验证邮件发送失败，根据邮箱删除出错");
            }
            return ResultBean.error("验证邮件发送失败");
        }
    }

    /**
     * 用户注册
     *
     * @param user 用户实体
     * @return
     */
    @PostMapping("/register")
    @ResponseBody
    public ResultBean userRegister(@RequestBody User user) {
        /**
         * 判断是否输入有邮箱号码
         */
        if (StringUtils.isEmpty(user.getEmail()) || user.getEmail() == null) {
            return ResultBean.error("请输入邮箱号码");
        }
        /**
         * 获取到用户邮箱，将邮箱作为键去取注册验证码
         */
        String code = "";
        if (redisUtil.get(user.getEmail()) != null) {
            code = redisUtil.get(user.getEmail()).toString();
        }
        /**
         * 判断是否已经失效
         */
        if (StringUtils.isEmpty(code) || code == null) {
            return ResultBean.error("注册验证码失效");
        }
        /**
         * 判断输入的验证码是否正确
         */
        if (!code.equals(user.getCode())) {
            return ResultBean.error("注册验证码输入错误");
        }
        //设置时间
        user.setCreateTime(new Date());
        //执行查询操作
        User user1 = userService.checkUserName(user.getLoginName());
        if (user1 != null) {
            return ResultBean.error("用户名已存在，请重新输入！");
        }
        User user2 = userService.checkMail(user.getEmail());
        //判断邮箱是否存在
        if (user2 != null) {
            return ResultBean.error("邮箱已存在，请输入真实有效的邮箱");
        }
        /**
         * 执行插入操作
         */
        try {
            if (user.getRoleId().equals(2)) {
                user.setStatus(0);
                boolean flag = userService.insertUser(user);
                return ResultBean.success("教师用户注册成功，等待管理员审批。");
            } else {
                user.setStatus(1);
                boolean flag = userService.insertUser(user);
                return ResultBean.success("用户注册成功");
            }
        } catch (Exception e) {
            return ResultBean.error("用户注册失败");
        }
    }


    /**
     * 用户登录
     *
     * @param user
     * @return
     */
    @PostMapping("/login")
    @ResponseBody
    public ResultBean userLogin(@RequestBody User user) {
        if (user == null) {
            return ResultBean.error("请输入用户名和密码");
        }
        User flag = userService.checkUser(user);
        if (!StringUtils.isEmpty(flag) || flag != null) {
            if (!flag.getRoleId().equals(user.getRoleId())) {
                return ResultBean.error("请选择登陆用户对应的身份。");
            }
            if (flag.getRoleId().equals(2) && flag.getStatus() != 1) {
                return ResultBean.error("尊敬的教师，您注册的账号尚未被激活。");
            }
            if (flag.getStatus() != 1) {
                return ResultBean.error("用户不存在");
            }
            String jwt = JwtUtil.sign(flag, 60 * 60 * 1000  * 24);
            logger.info(jwt);
            /**
             * 创建json对象
             */
            JSONObject jsonObject = (JSONObject) JSONObject.toJSON(flag);
            jsonObject.put("token", jwt);
            jsonObject.remove("password");
            return ResultBean.success("用户登陆成功", jsonObject);
        } else {
            return ResultBean.error("账号密码错误，请重新输入！");
        }
    }

    /**
     * 验证用户名是否存在
     */
    @PostMapping("/checkUserName")
    @ResponseBody
    public ResultBean checkUserName(@RequestBody String loginName) {
        /**
         * 解析输入的用户名
         */
        JSONObject rootObject = JSONObject.parseObject(loginName);
        String userName = rootObject.getString("loginName");
        //执行查询操作
        User user = userService.checkUserName(userName);
        if (user != null) {
            return ResultBean.error("用户已存在");
        } else {
            return ResultBean.success("用户名不存在，可以注册");
        }
    }

    /**
     * 验证邮箱是否存在
     */
    @PostMapping("/checkMail")
    @ResponseBody
    public ResultBean checkMail(@RequestBody String mail) {
        /**
         * 解析输入的邮箱
         */
        JSONObject rootObject = JSONObject.parseObject(mail);
        String email = rootObject.getString("mail");
        //执行根据邮箱查询操作
        User user = userService.checkMail(email);
        //判断你又想是否存在
        if (user != null) {
            return ResultBean.error("邮箱已存在");
        } else {
            return ResultBean.success("邮箱不存在，可以注册");
        }
    }

    /**
     * 忘记密码，修改密码
     *
     * @param loginName 用户名
     * @return
     */
    @PostMapping("/forgetPasswordSendMail")
    @ResponseBody
    public ResultBean forgetPasswordSendMail(@RequestBody String loginName) {
        /**
         * 解析出发送的用户名
         */
        JSONObject jsonObject = JSONObject.parseObject(loginName);
        String userName = jsonObject.getString("loginName");
        /**
         * 根据用户名获取对象
         */
        User user = userService.checkUserName(userName);
        if (StringUtils.isEmpty(user) || user == null) {
            return ResultBean.error("请填写用户名");
        }
        return sendMail2(user.getEmail());
    }

    /**
     * 修改密码
     *
     * @param user
     * @return
     */
    @PostMapping("/updatePassword")
    @ResponseBody
    public ResultBean updatePassword(@RequestBody User user) {
        if (StringUtils.isEmpty(user.getEmail()) || user.getEmail() == null) {
            return ResultBean.error("请输入注册时的邮箱");
        }
        /**
         * 根据用户名获取对象
         */
        User user1 = userService.checkUserName(user.getLoginName());
        if(!user1.getEmail().equals(user.getEmail())){
            return ResultBean.error("输入的邮箱与注册邮箱不匹配！");
        }
        /**
         * 获取到忘记密码时发送的验证码
         */
        String passwordCode = user.getPasswordCode();
        /**
         * 获取到redis中存放的验证码
         */
        String code = "";
        if (redisUtil.get(user.getEmail()) != null) {
            code = redisUtil.get(user.getEmail()).toString();
        }
        /**
         * 判断是否有输入验证码
         */
        if (StringUtils.isEmpty(passwordCode) || passwordCode == null) {
            return ResultBean.error("请输入验证码");
        }
        /**
         * 判断redis中存放的验证码是否失效
         */
        if (StringUtils.isEmpty(code) || code == null) {
            return ResultBean.error("验证码失效，请重新获取");
        }
        /**
         * 判断输入的验证码与redis中的是否相等
         */
        if (!passwordCode.equals(code)) {
            return ResultBean.error("验证码输入错误，请重新获取");
        }
        /**
         * 执行更新验证码操作
         */
        try {
            //执行更新操作
            userService.updatePassword(user);
            return ResultBean.success("密码修改成功");
        } catch (Exception e) {
            logger.error(user.getLoginName() + "密码修改失败");
            return ResultBean.error("密码修改失败");
        }
    }


    /**
     * 获取所有用户信息
     *
     * @param request
     * @param pageNum
     * @param pageSize
     * @return
     */
    @GetMapping("/getAllUser")
    @ResponseBody
    public ResultBean getAllUser(HttpServletRequest request, Integer pageNum, Integer pageSize) {
        //获取前端传来的token
        String token = request.getHeader("Authorization");
        if (token == null || token.equals("")) {
            return ResultBean.error("无token,请先登录");
        }
        String jwt = token.substring(token.lastIndexOf(" ") + 1);
        User u = JwtUtil.unsign(jwt, User.class);
        //判断token是否失效
        if (u == null) {
            return ResultBean.error("token无效");
        }
        if (StringUtils.isEmpty(pageNum) || pageNum == 0) {
            pageNum = 1;
        }
        if (StringUtils.isEmpty(pageSize) || pageSize == 0) {
            pageSize = 10;
        }
        try {
            PageHelper.startPage(pageNum, pageSize);
            /**
             * 查询所有用户信息
             */
            List<User> users = userService.getAllUser();
            PageInfo<User> pageInfo = new PageInfo<User>(users);
            return ResultBean.success("成功获取到用户信息", pageInfo);
        } catch (Exception e) {
            return ResultBean.error("没有获取到用户信息");
        }
    }

    /**
     * 游客登录
     *
     * @return
     */
    @PostMapping("/touristLogin")
    @ResponseBody
    public ResultBean touristLogin(HttpServletRequest request) {
        /**
         * 获取sessinId
         */
        /*String sessionId=request.getRequestedSessionId();
        System.out.println(sessionId);
        //查看redis是否有该session
        if(!StringUtils.isEmpty(redisUtil.get("wlrh"+sessionId)) || redisUtil.get("wlrh"+sessionId)!=null){
            return ResultBean.error("游客账号不能重复登录，若想使用请注册！");
        }*/
        User user = new User();
        user.setUserName("评审账户");
        user.setCreateTime(new Date());
        user.setLoginName(UUID.randomUUID().toString());
        user.setPassword("123456");
        user.setRoleId(4);
        user.setStatus(1);
        /**
         * 根据id获取地址
         */
        String ip=IpUtils.getIpAddr(request);
        String[] array1=ip.split(",");
        String address=AddressUtils.getAddressByIp(array1[0]);
        if(address.equals("地址未知")){
            user.setProvince(null);
            user.setCity(null);
        }else{
            String[] array=address.split(" ");
            user.setProvince(array[1].substring(0,2));
            user.setCity(array[2]);
        }
        try {
            userService.insertTourists(user);
            int id = user.getId();
            user.setId(id);
            /**
             * jwt设置   时间毫秒
             *           1*1000*60*30  30分钟
             */
            String jwt = JwtUtil.sign(user, 30 * 60 * 1000 * 2 * 24);
            /**
             * 创建json对象
             */
            JSONObject jsonObject = (JSONObject) JSONObject.toJSON(user);
            jsonObject.put("token", jwt);
            jsonObject.remove("password");
            /**
             * 将游客账号存入redis,设置三分钟
             */
            //redisUtil.set("wlrh"+sessionId,"游客账号添加",180);
            return ResultBean.success("游客登录成功", jsonObject);
        } catch (Exception e) {
            return ResultBean.error("游客登录失败");
        }
    }


    /**
     * 获取未审批的教师用户信息
     *
     * @param request
     * @return
     */
    @GetMapping("/getUserNoUse")
    @ResponseBody
    public ResultBean getAllTeacherNoUse(HttpServletRequest request) {
        //获取前端传来的token
        String token = request.getHeader("Authorization");
        if (token == null || token.equals("")) {
            return ResultBean.error("无token,请先登录");
        }
        String jwt = token.substring(token.lastIndexOf(" ") + 1);
        User u = JwtUtil.unsign(jwt, User.class);
        //判断token是否失效
        if (u == null) {
            return ResultBean.error("token无效");
        }
        /**
         * 判断是否是管理员账号
         */
        if (!u.getRoleId().equals(1)) {
            return ResultBean.error("抱歉，您没有查看数据的权限");
        }
        /**
         * 获取教师注册账号，进行注册审批
         */
        List<User> userList = userService.getUserNoUse();
        if (StringUtils.isEmpty(userList) || userList.size() == 0) {
            return ResultBean.error("没有要审批的教师");
        }
        return ResultBean.success("获取未审批教师用户成功", userList);
    }


    /**
     * 审批注册的教师用户
     * @param request
     * @param data
     * @return
     */
    @PostMapping("/approve")
    @ResponseBody
    public ResultBean approve(HttpServletRequest request,@RequestBody String data){
        //获取前端传来的token
        String token = request.getHeader("Authorization");
        if (token == null || token.equals("")) {
            return ResultBean.error("无token,请先登录");
        }
        String jwt = token.substring(token.lastIndexOf(" ") + 1);
        User u = JwtUtil.unsign(jwt, User.class);
        //判断token是否失效
        if (u == null) {
            return ResultBean.error("token无效");
        }
        /**
         * 判断是否是管理员账号
         */
        if (!u.getRoleId().equals(1)) {
            return ResultBean.error("抱歉，您没有查看数据的权限,管理员才可操作");
        }
        /**
         * 解析json字符串
         */
        JSONObject jsonObject=JSONObject.parseObject(data);
        /**
         * 去掉两端的括号
         */
        String str=jsonObject.getString("userIds");
        String dataSearchIds=str.substring(1,str.length()-1);
        /**
         * 分割逗号为数组 转为集合
         */
        List<String> list= Arrays.asList(dataSearchIds.split(","));
        try{
            userService.approve(list);
            return ResultBean.success("审批成功");
        }catch (Exception e){
            return ResultBean.error("审批失败");
        }
    }

    /**
     * 删除用户
     *
     * @param request
     * @return
     */
    @PostMapping("/deleteUser")
    @ResponseBody
    public ResultBean deleteUser(HttpServletRequest request, @RequestBody String data) {
        //获取前端传来的token
        String token = request.getHeader("Authorization");
        if (token == null || token.equals("")) {
            return ResultBean.error("无token,请先登录");
        }
        String jwt = token.substring(token.lastIndexOf(" ") + 1);
        User u = JwtUtil.unsign(jwt, User.class);
        //判断token是否失效
        if (u == null) {
            return ResultBean.error("token无效");
        }
        /**
         * 判断是否是管理员账号
         */
        if (!u.getRoleId().equals(1)) {
            return ResultBean.error("抱歉，您没有查看数据的权限");
        }
        /**
         * 解析json参数
         */
        JSONObject jsonObject = JSONObject.parseObject(data);
        int userId = jsonObject.getInteger("userId");
        try {
            /**
             * 执行删除方法
             */
            userService.deleteUser(userId);
            return ResultBean.success("用户删除成功");
        } catch (Exception e) {
            return ResultBean.error("用户删除失败");
        }
    }


    /**
     * 根据用户id查询用户信息
     *
     * @param request
     * @param userId  json字符串
     * @return
     */
    @GetMapping("/getUserById")
    @ResponseBody
    public ResultBean getUserById(HttpServletRequest request, int userId) {
        //获取前端传来的token
        String token = request.getHeader("Authorization");
        if (token == null || token.equals("")) {
            return ResultBean.error("无token,请先登录");
        }
        String jwt = token.substring(token.lastIndexOf(" ") + 1);
        User u = JwtUtil.unsign(jwt, User.class);
        //判断token是否失效
        if (u == null) {
            return ResultBean.error("token无效");
        }
        /**
         * 执行查询操作
         */
        try {
            User user = userService.getUserById(userId);
            return ResultBean.success("查询成功", user);
        } catch (Exception e) {
            e.printStackTrace();
            return ResultBean.error("查询失败");
        }
    }


    /**
     * 根据搜索内容查询用户信息
     *
     * @param request
     * @param message
     * @param pageSize
     * @param pageNum
     * @return
     */
    @GetMapping("/getUserByMessage")
    @ResponseBody
    public ResultBean getUserByMessage(HttpServletRequest request, String message, Integer roleId, Integer pageSize, Integer pageNum) {
        //获取前端传来的token
        String token = request.getHeader("Authorization");
        if (token == null || token.equals("")) {
            return ResultBean.error("无token,请先登录");
        }
        String jwt = token.substring(token.lastIndexOf(" ") + 1);
        User u = JwtUtil.unsign(jwt, User.class);
        //判断token是否失效
        if (u == null) {
            return ResultBean.error("token无效");
        }
        /**
         * 判断是否传页码和显示条数
         */
        if (StringUtils.isEmpty(pageNum) || pageNum == null) {
            pageNum = 1;
        }
        if (StringUtils.isEmpty(pageSize) || pageSize == null) {
            pageSize = 10;
        }
        try {
            /**
             * 執行分頁
             */
            PageHelper.startPage(pageNum, pageSize);
            //獲取數據
            List<User> users = userService.getUserByMessage(message,roleId);
            PageInfo<User> pageInfo = new PageInfo<User>(users);
            return ResultBean.success("获取用户数据成功", pageInfo);
        } catch (Exception e) {
            e.printStackTrace();
            return ResultBean.error("获取用户数据失败");
        }
    }


    /**
     * 管理员添加管理账号
     * @param user
     * @param request
     * @return
     */
    @PostMapping("/insertAdmin")
    @ResponseBody
    public ResultBean insertAdmin(@RequestBody User user,HttpServletRequest request){
        //获取前端传来的token
        String token = request.getHeader("Authorization");
        if (token == null || token.equals("")) {
            return ResultBean.error("无token,请先登录");
        }
        String jwt = token.substring(token.lastIndexOf(" ") + 1);
        User u = JwtUtil.unsign(jwt, User.class);
        //判断token是否失效
        if (u == null) {
            return ResultBean.error("token无效");
        }
        /**
         * 判断是否是管理员账号
         */
        if (!u.getRoleId().equals(1)) {
            return ResultBean.error("抱歉，您没有查看操作此项的权限");
        }
        //设置时间
        user.setCreateTime(new Date());
        user.setStatus(1);
        user.setRoleId(1);
        //执行查询操作
        User user1 = userService.checkUserName(user.getLoginName());
        if (user1 != null) {
            return ResultBean.error("用户名已存在，请重新输入！");
        }
        User user2 = userService.checkMail(user.getEmail());
        //判断邮箱是否存在
        if (user2 != null) {
            return ResultBean.error("邮箱已存在，请输入真实有效的邮箱");
        }
        try{
            userService.insertUser(user);
            return ResultBean.success("添加管理员账号成功");
        }catch (Exception e){
            return ResultBean.error("添加管理员账号失败");
        }
    }
}
